類別

• 類別為一種由使用者自行設計的資料型別
  • Data Member (屬性)：儲存資料
  • Member Function (行為)：操縱data member
• 物件：類別變數
• 類別不佔記憶體，但宣告後，作業系統會找一塊記憶體存放物件，故佔記憶體。

函式導向

處理資料的方式為將資料丟進Function中處理

const int SIZE = 10;
enum Status { EMPTY, OCCUPIED };
struct Set {
	int element[SIZE];
	Status status[SIZE];
	int element_no;
};

void set_initialization(Set& foo){
	for (int i = 0; i < SIZE; i++){
		foo.status[i] = EMPTY;
		foo.element_no = 0;
        }
    }

bool insert_element(Set& s, int data){
	if (s.element_no == SIZE)
		return false;

	for (int i = 0; i < SIZE; i++){
		if (s.status[i] == EMPTY){
			s.element[i] = data;
			s.status[i] = OCCUPIED;
			s.element_no++;
			return true;
        }
	}
}

int delete_element(Set& s, int data){
	int count = 0;
	for (int i = 0; i < SIZE; i++){
		if (s.status[i] == OCCUPIED && s.element[i] == data){
			s.status[i] = EMPTY;
			s.element_no--;
			count++;
		}
	}
	return count;
}

void print_set(const Set& foo){
	for (int i = 0; i < SIZE; i++){
		if (foo.status[i] == OCCUPIED)
			cout << foo.element[i] << ' ';}
	cout << endl;
}

int main()
{
	Set mySet;
	set_initialization(mySet);
	print_set(mySet);
	insert_element(mySet, 5);
	insert_element(mySet, 7);
	insert_element(mySet, 8);
	print_set(mySet);
	delete_element(mySet, 4);
	print_set(mySet);
	delete_element(mySet, 5);
	print_set(mySet);
    return 0;
}

優化

將函式原型提出

const int SIZE = 10;
enum Status { EMPTY, OCCUPIED };
struct Set {
	int element[SIZE];
	Status status[SIZE];
	int element_no;
};

//函示原型
void set_initialization(Set&);
bool insert_element(Set&, int);
int delete_element(Set&, int);
void print_set(const Set&);

int main()
{
	...
}

void set_initialization(Set& foo){
	...
}

bool insert_element(Set& s, int data){
	...
}

int delete_element(Set& s, int data){
	...
}

void print_set(const Set& foo){
	...
}

物件導向 與 函式導向思維上的不同

• 函式導向：將記憶體傳至函示處理，傳來傳去。
• 物件導向：站在此記憶體(物件)上，由身邊的函示提供處理方法，對比函式導向少了記憶體傳遞動作。
  精神：每次修改物件均要透過已設計好的函式，減少錯誤。

物件導向的封裝概念

• 物件操作具權限的保護
• 物件導向三大重點：封裝、繼承、多型

函式導向 -> 物件導向

• 函式從一般函式 變為 成員函式(member function)
• 成員函式定義在外要加上範圍運算子(::)

class Set
{
private:
	int element[SIZE];
	Status status[SIZE];
	int element_no;

public:
	void set_initialization();
	bool insert_element(int);
	int delete_element(int);
	void print_set() const; //const代表此函示不會改變data member
};

int main()
{
	Set mySet;
	mySet.set_initialization();
	mySet.print_set();
	mySet.insert_element(5);
	mySet.insert_element(7);
	mySet.insert_element(8);
	mySet.print_set();
	mySet.delete_element(4);
	mySet.print_set();
	mySet.delete_element(5);
	mySet.print_set();
	return 0;
}

void Set::set_initialization(){
	for (int i = 0; i < SIZE; i++){
		status[i] = EMPTY;
		element_no = 0;
	}
}

bool Set::insert_element(int data){
	if (element_no == SIZE)
		return false;

	for (int i = 0; i < SIZE; i++){
		if (status[i] == EMPTY){
			element[i] = data;
			status[i] = OCCUPIED;
			element_no++;
			return true;
		}
	}
}

int Set::delete_element(int data){
	int count = 0;
	for (int i = 0; i < SIZE; i++){
		if (status[i] == OCCUPIED && element[i] == data){
			status[i] = EMPTY;
			element_no--;
			count++;
		}
	}
	return count;
}

void Set::print_set() const{
	for (int i = 0; i < SIZE; i++){
		if (status[i] == OCCUPIED)
			cout << element[i] << ' ';
	}
	cout << endl;
}